/*******************************************************************************
* Copyright (c) 2000, 2011 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
* Dmitry Stalnov (dstalnov@fusionone.com) - contributed fix for
* o bug "inline method - doesn't handle implicit cast" (see
* https://bugs.eclipse.org/bugs/show_bug.cgi?id=24941).
* o inline call that is used in a field initializer
* (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=38137)
* o inline call a field initializer: could detect self reference
* (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=44417)
*******************************************************************************/
package org.eclipse.jdt.internal.corext.refactoring.code;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.filebuffers.ITextFileBuffer;
import org.eclipse.text.edits.MalformedTreeException;
import org.eclipse.text.edits.MultiTextEdit;
import org.eclipse.text.edits.RangeMarker;
import org.eclipse.text.edits.TextEdit;
import org.eclipse.text.edits.TextEditProcessor;
import org.eclipse.text.edits.UndoEdit;
import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.Document;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.IRegion;
import org.eclipse.jface.text.Region;
import org.eclipse.jface.text.TextUtilities;
import org.eclipse.ltk.core.refactoring.RefactoringStatus;
import org.eclipse.jdt.core.ITypeRoot;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.core.dom.AST;
import org.eclipse.jdt.core.dom.ASTNode;
import org.eclipse.jdt.core.dom.ASTVisitor;
import org.eclipse.jdt.core.dom.Block;
import org.eclipse.jdt.core.dom.CastExpression;
import org.eclipse.jdt.core.dom.ChildPropertyDescriptor;
import org.eclipse.jdt.core.dom.ClassInstanceCreation;
import org.eclipse.jdt.core.dom.CompilationUnit;
import org.eclipse.jdt.core.dom.ConditionalExpression;
import org.eclipse.jdt.core.dom.DoStatement;
import org.eclipse.jdt.core.dom.EnhancedForStatement;
import org.eclipse.jdt.core.dom.Expression;
import org.eclipse.jdt.core.dom.FieldAccess;
import org.eclipse.jdt.core.dom.ForStatement;
import org.eclipse.jdt.core.dom.IBinding;
import org.eclipse.jdt.core.dom.IMethodBinding;
import org.eclipse.jdt.core.dom.ITypeBinding;
import org.eclipse.jdt.core.dom.IVariableBinding;
import org.eclipse.jdt.core.dom.IfStatement;
import org.eclipse.jdt.core.dom.LabeledStatement;
import org.eclipse.jdt.core.dom.MethodDeclaration;
import org.eclipse.jdt.core.dom.MethodInvocation;
import org.eclipse.jdt.core.dom.Modifier;
import org.eclipse.jdt.core.dom.Name;
import org.eclipse.jdt.core.dom.ParenthesizedExpression;
import org.eclipse.jdt.core.dom.ReturnStatement;
import org.eclipse.jdt.core.dom.SimpleName;
import org.eclipse.jdt.core.dom.SingleVariableDeclaration;
import org.eclipse.jdt.core.dom.Statement;
import org.eclipse.jdt.core.dom.StructuralPropertyDescriptor;
import org.eclipse.jdt.core.dom.ThisExpression;
import org.eclipse.jdt.core.dom.WhileStatement;
import org.eclipse.jdt.core.dom.rewrite.ASTRewrite;
import org.eclipse.jdt.core.dom.rewrite.ImportRewrite;
import org.eclipse.jdt.core.dom.rewrite.ImportRewrite.ImportRewriteContext;
import org.eclipse.jdt.internal.corext.codemanipulation.ContextSensitiveImportRewriteContext;
import org.eclipse.jdt.internal.corext.dom.ASTNodes;
import org.eclipse.jdt.internal.corext.dom.Bindings;
import org.eclipse.jdt.internal.corext.dom.CodeScopeBuilder;
import org.eclipse.jdt.internal.corext.dom.NecessaryParenthesesChecker;
import org.eclipse.jdt.internal.corext.refactoring.code.SourceAnalyzer.NameData;
import org.eclipse.jdt.internal.corext.refactoring.util.RefactoringFileBuffers;
import org.eclipse.jdt.internal.corext.util.CodeFormatterUtil;
import org.eclipse.jdt.internal.corext.util.Strings;
import org.eclipse.jdt.internal.ui.JavaPlugin;
/**
* A SourceProvider encapsulates a piece of code (source) and the logic
* to inline it into given CallContexts.
*/
public class SourceProvider {
private ITypeRoot fTypeRoot;
private IDocument fDocument;
private MethodDeclaration fDeclaration;
private SourceAnalyzer fAnalyzer;
private boolean fMustEvalReturnedExpression;
private boolean fReturnValueNeedsLocalVariable;
private List<Expression> fReturnExpressions;
private IDocument fSource;
private static final int EXPRESSION_MODE= 1;
private static final int STATEMENT_MODE= 2;
private static final int RETURN_STATEMENT_MODE= 3;
private int fMarkerMode;
private class ReturnAnalyzer extends ASTVisitor {
@Override
public boolean visit(ReturnStatement node) {
Expression expression= node.getExpression();
if (!(ASTNodes.isLiteral(expression) || expression instanceof Name)) {
fMustEvalReturnedExpression= true;
}
if (Invocations.isInvocation(expression) || expression instanceof ClassInstanceCreation) {
fReturnValueNeedsLocalVariable= false;
}
fReturnExpressions.add(expression);
return false;
}
}
public SourceProvider(ITypeRoot typeRoot, MethodDeclaration declaration) {
super();
fTypeRoot= typeRoot;
fDeclaration= declaration;
List<SingleVariableDeclaration> parameters= fDeclaration.parameters();
for (Iterator<SingleVariableDeclaration> iter= parameters.iterator(); iter.hasNext();) {
SingleVariableDeclaration element= iter.next();
ParameterData data= new ParameterData(element);
element.setProperty(ParameterData.PROPERTY, data);
}
fAnalyzer= new SourceAnalyzer(fTypeRoot, fDeclaration);
fReturnValueNeedsLocalVariable= true;
fReturnExpressions= new ArrayList<Expression>();
}
/**
* TODO: unit's source does not match contents of source document and declaration node.
* @param typeRoot the type root
* @param source document containing the content of the type root
* @param declaration method declaration node
*/
public SourceProvider(ITypeRoot typeRoot, IDocument source, MethodDeclaration declaration) {
this(typeRoot, declaration);
fSource= source;
}
public RefactoringStatus checkActivation() throws JavaModelException {
return fAnalyzer.checkActivation();
}
public void initialize() throws JavaModelException {
fDocument= fSource == null ? new Document(fTypeRoot.getBuffer().getContents()) : fSource;
fAnalyzer.initialize();
if (hasReturnValue()) {
ASTNode last= getLastStatement();
if (last != null) {
ReturnAnalyzer analyzer= new ReturnAnalyzer();
last.accept(analyzer);
}
}
}
public boolean isExecutionFlowInterrupted() {
return fAnalyzer.isExecutionFlowInterrupted();
}
static class VariableReferenceFinder extends ASTVisitor {
private boolean fResult;
private IVariableBinding fBinding;
public VariableReferenceFinder(IVariableBinding binding) {
fBinding= binding;
}
public boolean getResult() {
return fResult;
}
@Override
public boolean visit(SimpleName node) {
if(!fResult) {
fResult= Bindings.equals(fBinding, node.resolveBinding());
}
return false;
}
}
/**
* Checks whether variable is referenced by the method declaration or not.
*
* @param binding binding of variable to check.
* @return <code>true</code> if variable is referenced by the method, otherwise <code>false</code>
*/
public boolean isVariableReferenced(IVariableBinding binding) {
VariableReferenceFinder finder= new VariableReferenceFinder(binding);
fDeclaration.accept(finder);
return finder.getResult();
}
public boolean hasReturnValue() {
IMethodBinding binding= fDeclaration.resolveBinding();
return binding.getReturnType() != fDeclaration.getAST().resolveWellKnownType("void"); //$NON-NLS-1$
}
// returns true if the declaration has a vararg and
// the body contains an array access to the vararg
public boolean hasArrayAccess() {
return fAnalyzer.hasArrayAccess();
}
public boolean hasSuperMethodInvocation() {
return fAnalyzer.hasSuperMethodInvocation();
}
public boolean mustEvaluateReturnedExpression() {
return fMustEvalReturnedExpression;
}
public boolean returnValueNeedsLocalVariable() {
return fReturnValueNeedsLocalVariable;
}
public int getNumberOfStatements() {
return fDeclaration.getBody().statements().size();
}
public boolean isSimpleFunction() {
List<Statement> statements= fDeclaration.getBody().statements();
if (statements.size() != 1)
return false;
return statements.get(0) instanceof ReturnStatement;
}
public boolean isLastStatementReturn() {
List<Statement> statements= fDeclaration.getBody().statements();
if (statements.size() == 0)
return false;
return statements.get(statements.size() - 1) instanceof ReturnStatement;
}
public boolean isDangligIf() {
List<Statement> statements= fDeclaration.getBody().statements();
if (statements.size() != 1)
return false;
ASTNode p= statements.get(0);
while (true) {
if (p instanceof IfStatement) {
return ((IfStatement) p).getElseStatement() == null;
} else {
ChildPropertyDescriptor childD;
if (p instanceof WhileStatement) {
childD= WhileStatement.BODY_PROPERTY;
} else if (p instanceof ForStatement) {
childD= ForStatement.BODY_PROPERTY;
} else if (p instanceof EnhancedForStatement) {
childD= EnhancedForStatement.BODY_PROPERTY;
} else if (p instanceof DoStatement) {
childD= DoStatement.BODY_PROPERTY;
} else if (p instanceof LabeledStatement) {
childD= LabeledStatement.BODY_PROPERTY;
} else {
return false;
}
Statement body= (Statement) p.getStructuralProperty(childD);
if (body instanceof Block) {
return false;
} else {
p= body;
}
}
}
}
public MethodDeclaration getDeclaration() {
return fDeclaration;
}
public String getMethodName() {
return fDeclaration.getName().getIdentifier();
}
public ITypeBinding getReturnType() {
return fDeclaration.resolveBinding().getReturnType();
}
public List<Expression> getReturnExpressions() {
return fReturnExpressions;
}
public boolean returnTypeMatchesReturnExpressions() {
ITypeBinding returnType= getReturnType();
for (Iterator<Expression> iter= fReturnExpressions.iterator(); iter.hasNext();) {
Expression expression= iter.next();
if (!Bindings.equals(returnType, expression.resolveTypeBinding()))
return false;
}
return true;
}
public ParameterData getParameterData(int index) {
SingleVariableDeclaration decl= (SingleVariableDeclaration)fDeclaration.parameters().get(index);
return (ParameterData)decl.getProperty(ParameterData.PROPERTY);
}
public ITypeRoot getTypeRoot() {
return fTypeRoot;
}
public boolean needsReturnedExpressionParenthesis(ASTNode parent, StructuralPropertyDescriptor locationInParent) {
ASTNode last= getLastStatement();
if (last instanceof ReturnStatement) {
return NecessaryParenthesesChecker.needsParentheses(((ReturnStatement)last).getExpression(), parent, locationInParent);
}
return false;
}
public boolean returnsConditionalExpression() {
ASTNode last= getLastStatement();
if (last instanceof ReturnStatement) {
return ((ReturnStatement)last).getExpression() instanceof ConditionalExpression;
}
return false;
}
public int getReceiversToBeUpdated() {
return fAnalyzer.getImplicitReceivers().size();
}
public boolean isVarargs() {
return fDeclaration.isVarargs();
}
public int getVarargIndex() {
return fDeclaration.parameters().size() - 1;
}
public TextEdit getDeleteEdit() {
final ASTRewrite rewriter= ASTRewrite.create(fDeclaration.getAST());
rewriter.remove(fDeclaration, null);
return rewriter.rewriteAST(fDocument, fTypeRoot.getJavaProject().getOptions(true));
}
public String[] getCodeBlocks(CallContext context, ImportRewrite importRewrite) throws CoreException {
final ASTRewrite rewriter= ASTRewrite.create(fDeclaration.getAST());
replaceParameterWithExpression(rewriter, context, importRewrite);
updateImplicitReceivers(rewriter, context);
makeNamesUnique(rewriter, context.scope);
updateTypeReferences(rewriter, context);
updateStaticReferences(rewriter, context);
updateTypeVariables(rewriter, context);
updateMethodTypeVariable(rewriter, context);
List<IRegion> ranges= null;
if (hasReturnValue()) {
if (context.callMode == ASTNode.RETURN_STATEMENT) {
ranges= getStatementRanges();
} else {
ranges= getExpressionRanges();
}
} else {
ASTNode last= getLastStatement();
if (last != null && last.getNodeType() == ASTNode.RETURN_STATEMENT) {
ranges= getReturnStatementRanges();
} else {
ranges= getStatementRanges();
}
}
final TextEdit dummy= rewriter.rewriteAST(fDocument, fTypeRoot.getJavaProject().getOptions(true));
int size= ranges.size();
RangeMarker[] markers= new RangeMarker[size];
for (int i= 0; i < markers.length; i++) {
IRegion range= ranges.get(i);
markers[i]= new RangeMarker(range.getOffset(), range.getLength());
}
int split;
if (size <= 1) {
split= Integer.MAX_VALUE;
} else {
IRegion region= ranges.get(0);
split= region.getOffset() + region.getLength();
}
TextEdit[] edits= dummy.removeChildren();
for (int i= 0; i < edits.length; i++) {
TextEdit edit= edits[i];
int pos= edit.getOffset() >= split ? 1 : 0;
markers[pos].addChild(edit);
}
MultiTextEdit root= new MultiTextEdit(0, fDocument.getLength());
root.addChildren(markers);
try {
TextEditProcessor processor= new TextEditProcessor(fDocument, root, TextEdit.CREATE_UNDO | TextEdit.UPDATE_REGIONS);
UndoEdit undo= processor.performEdits();
String[] result= getBlocks(markers);
// It is faster to undo the changes than coping the buffer over and over again.
processor= new TextEditProcessor(fDocument, undo, TextEdit.UPDATE_REGIONS);
processor.performEdits();
return result;
} catch (MalformedTreeException exception) {
JavaPlugin.log(exception);
} catch (BadLocationException exception) {
JavaPlugin.log(exception);
}
return new String[] {};
}
private Expression createParenthesizedExpression(Expression newExpression, AST ast) {
ParenthesizedExpression parenthesized= ast.newParenthesizedExpression();
parenthesized.setExpression(newExpression);
return parenthesized;
}
private void replaceParameterWithExpression(ASTRewrite rewriter, CallContext context, ImportRewrite importRewrite) throws CoreException {
Expression[] arguments= context.arguments;
try {
ITextFileBuffer buffer= RefactoringFileBuffers.acquire(context.compilationUnit);
for (int i= 0; i < arguments.length; i++) {
Expression expression= arguments[i];
String expressionString= null;
if (expression instanceof SimpleName) {
expressionString= ((SimpleName)expression).getIdentifier();
} else {
try {
expressionString= buffer.getDocument().get(expression.getStartPosition(), expression.getLength());
} catch (BadLocationException exception) {
JavaPlugin.log(exception);
continue;
}
}
ParameterData parameter= getParameterData(i);
List<SimpleName> references= parameter.references();
for (Iterator<SimpleName> iter= references.iterator(); iter.hasNext();) {
ASTNode element= iter.next();
Expression newExpression= (Expression)rewriter.createStringPlaceholder(expressionString, expression.getNodeType());
AST ast= rewriter.getAST();
ITypeBinding explicitCast= ASTNodes.getExplicitCast(expression, (Expression)element);
if (explicitCast != null) {
CastExpression cast= ast.newCastExpression();
if (NecessaryParenthesesChecker.needsParentheses(expression, cast, CastExpression.EXPRESSION_PROPERTY)) {
newExpression= createParenthesizedExpression(newExpression, ast);
}
cast.setExpression(newExpression);
ImportRewriteContext importRewriteContext= new ContextSensitiveImportRewriteContext(expression, importRewrite);
cast.setType(importRewrite.addImport(explicitCast, ast, importRewriteContext));
expression= newExpression= cast;
}
if (NecessaryParenthesesChecker.needsParentheses(expression, element.getParent(), element.getLocationInParent())) {
newExpression= createParenthesizedExpression(newExpression, ast);
}
rewriter.replace(element, newExpression, null);
}
}
} finally {
RefactoringFileBuffers.release(context.compilationUnit);
}
}
private void makeNamesUnique(ASTRewrite rewriter, CodeScopeBuilder.Scope scope) {
Collection<NameData> usedCalleeNames= fAnalyzer.getUsedNames();
for (Iterator<NameData> iter= usedCalleeNames.iterator(); iter.hasNext();) {
SourceAnalyzer.NameData nd= iter.next();
if (scope.isInUse(nd.getName())) {
String newName= scope.createName(nd.getName(), true);
List<SimpleName> references= nd.references();
for (Iterator<SimpleName> refs= references.iterator(); refs.hasNext();) {
SimpleName element= refs.next();
ASTNode newNode= rewriter.createStringPlaceholder(newName, ASTNode.METHOD_INVOCATION);
rewriter.replace(element, newNode, null);
}
}
}
}
private void updateImplicitReceivers(ASTRewrite rewriter, CallContext context) {
if (context.receiver == null)
return;
List<Expression> implicitReceivers= fAnalyzer.getImplicitReceivers();
for (Iterator<Expression> iter= implicitReceivers.iterator(); iter.hasNext();) {
ASTNode node= iter.next();
ImportRewriteContext importRewriteContext= new ContextSensitiveImportRewriteContext(node, context.importer);
if (node instanceof MethodInvocation) {
final MethodInvocation inv= (MethodInvocation)node;
rewriter.set(inv, MethodInvocation.EXPRESSION_PROPERTY, createReceiver(rewriter, context, (IMethodBinding)inv.getName().resolveBinding(), importRewriteContext), null);
} else if (node instanceof ClassInstanceCreation) {
final ClassInstanceCreation inst= (ClassInstanceCreation)node;
rewriter.set(inst, ClassInstanceCreation.EXPRESSION_PROPERTY, createReceiver(rewriter, context, inst.resolveConstructorBinding(), importRewriteContext), null);
} else if (node instanceof ThisExpression) {
rewriter.replace(node, rewriter.createStringPlaceholder(context.receiver, ASTNode.METHOD_INVOCATION), null);
} else if (node instanceof FieldAccess) {
final FieldAccess access= (FieldAccess)node;
rewriter.set(access, FieldAccess.EXPRESSION_PROPERTY, createReceiver(rewriter, context, access.resolveFieldBinding(), importRewriteContext), null);
} else if (node instanceof SimpleName && ((SimpleName)node).resolveBinding() instanceof IVariableBinding) {
IVariableBinding vb= (IVariableBinding)((SimpleName)node).resolveBinding();
if (vb.isField()) {
Expression receiver= createReceiver(rewriter, context, vb, importRewriteContext);
if (receiver != null) {
FieldAccess access= node.getAST().newFieldAccess();
ASTNode target= rewriter.createMoveTarget(node);
access.setName((SimpleName)target);
access.setExpression(receiver);
rewriter.replace(node, access, null);
}
}
}
}
}
private void updateTypeReferences(ASTRewrite rewriter, CallContext context) {
ImportRewrite importer= context.importer;
for (Iterator<SimpleName> iter= fAnalyzer.getTypesToImport().iterator(); iter.hasNext();) {
Name element= iter.next();
ITypeBinding binding= ASTNodes.getTypeBinding(element);
if (binding != null && !binding.isLocal()) {
// We have collected names not types. So we have to import
// the declaration type if we reference a parameterized type
// since we have an entry for every name node (e.g. one for
// Vector and one for Integer in Vector<Integer>.
if (binding.isParameterizedType()) {
binding= binding.getTypeDeclaration();
}
String s= importer.addImport(binding);
if (!ASTNodes.asString(element).equals(s)) {
rewriter.replace(element, rewriter.createStringPlaceholder(s, ASTNode.SIMPLE_NAME), null);
}
}
}
}
private void updateStaticReferences(ASTRewrite rewriter, CallContext context) {
ImportRewrite importer= context.importer;
for (Iterator<SimpleName> iter= fAnalyzer.getStaticsToImport().iterator(); iter.hasNext();) {
Name element= iter.next();
IBinding binding= element.resolveBinding();
if (binding != null) {
String s= importer.addStaticImport(binding);
if (!ASTNodes.asString(element).equals(s)) {
rewriter.replace(element, rewriter.createStringPlaceholder(s, ASTNode.SIMPLE_NAME), null);
}
}
}
}
private Expression createReceiver(ASTRewrite rewriter, CallContext context, IMethodBinding method, ImportRewriteContext importRewriteContext) {
String receiver= getReceiver(context, method.getModifiers(), importRewriteContext);
if (receiver == null)
return null;
return (Expression)rewriter.createStringPlaceholder(receiver, ASTNode.METHOD_INVOCATION);
}
private Expression createReceiver(ASTRewrite rewriter, CallContext context, IVariableBinding field, ImportRewriteContext importRewriteContext) {
String receiver= getReceiver(context, field.getModifiers(), importRewriteContext);
if (receiver == null)
return null;
return (Expression)rewriter.createStringPlaceholder(receiver, ASTNode.SIMPLE_NAME);
}
private String getReceiver(CallContext context, int modifiers, ImportRewriteContext importRewriteContext) {
String receiver= context.receiver;
ITypeBinding invocationType= ASTNodes.getEnclosingType(context.invocation);
ITypeBinding sourceType= fDeclaration.resolveBinding().getDeclaringClass();
if (!context.receiverIsStatic && Modifier.isStatic(modifiers)) {
if ("this".equals(receiver) && invocationType != null && Bindings.equals(invocationType, sourceType)) { //$NON-NLS-1$
receiver= null;
} else {
receiver= context.importer.addImport(sourceType, importRewriteContext);
}
}
return receiver;
}
private void updateTypeVariables(ASTRewrite rewriter, CallContext context) {
ITypeBinding type= context.getReceiverType();
if (type == null)
return;
rewriteReferences(rewriter, type.getTypeArguments(), fAnalyzer.getTypeParameterReferences());
}
private void updateMethodTypeVariable(ASTRewrite rewriter, CallContext context) {
IMethodBinding method= Invocations.resolveBinding(context.invocation);
if (method == null)
return;
rewriteReferences(rewriter, method.getTypeArguments(), fAnalyzer.getMethodTypeParameterReferences());
}
private void rewriteReferences(ASTRewrite rewriter, ITypeBinding[] typeArguments, List<NameData> typeParameterReferences) {
if (typeArguments.length == 0)
return;
Assert.isTrue(typeArguments.length == typeParameterReferences.size());
for (int i= 0; i < typeArguments.length; i++) {
SourceAnalyzer.NameData refData= typeParameterReferences.get(i);
List<SimpleName> references= refData.references();
String newName= typeArguments[i].getName();
for (Iterator<SimpleName> iter= references.iterator(); iter.hasNext();) {
SimpleName name= iter.next();
rewriter.replace(name, rewriter.createStringPlaceholder(newName, ASTNode.SIMPLE_NAME), null);
}
}
}
private ASTNode getLastStatement() {
List<Statement> statements= fDeclaration.getBody().statements();
if (statements.isEmpty())
return null;
return statements.get(statements.size() - 1);
}
private List<IRegion> getReturnStatementRanges() {
fMarkerMode= RETURN_STATEMENT_MODE;
List<IRegion> result= new ArrayList<IRegion>(1);
List<Statement> statements= fDeclaration.getBody().statements();
int size= statements.size();
if (size <= 1)
return result;
result.add(createRange(statements, size - 2));
return result;
}
private List<IRegion> getStatementRanges() {
fMarkerMode= STATEMENT_MODE;
List<IRegion> result= new ArrayList<IRegion>(1);
List<Statement> statements= fDeclaration.getBody().statements();
int size= statements.size();
if (size == 0)
return result;
result.add(createRange(statements, size - 1));
return result;
}
private List<IRegion> getExpressionRanges() {
fMarkerMode= EXPRESSION_MODE;
List<IRegion> result= new ArrayList<IRegion>(2);
List<Statement> statements= fDeclaration.getBody().statements();
ReturnStatement rs= null;
int size= statements.size();
ASTNode node;
switch (size) {
case 0:
return result;
case 1:
node= statements.get(0);
if (node.getNodeType() == ASTNode.RETURN_STATEMENT) {
rs= (ReturnStatement)node;
} else {
result.add(createRange(node, node));
}
break;
default: {
node= statements.get(size - 1);
if (node.getNodeType() == ASTNode.RETURN_STATEMENT) {
result.add(createRange(statements, size - 2));
rs= (ReturnStatement)node;
} else {
result.add(createRange(statements, size - 1));
}
break;
}
}
if (rs != null) {
Expression exp= rs.getExpression();
result.add(createRange(exp, exp));
}
return result;
}
private IRegion createRange(List<Statement> statements, int end) {
ASTNode first= statements.get(0);
ASTNode last= statements.get(end);
return createRange(first, last);
}
private IRegion createRange(ASTNode first, ASTNode last) {
ASTNode root= first.getRoot();
if (root instanceof CompilationUnit) {
CompilationUnit unit= (CompilationUnit)root;
int start= unit.getExtendedStartPosition(first);
int length = unit.getExtendedStartPosition(last) - start + unit.getExtendedLength(last);
IRegion range= new Region(start, length);
return range;
} else {
int start= first.getStartPosition();
int length = last.getStartPosition() - start + last.getLength();
IRegion range= new Region(start, length);
return range;
}
}
private String[] getBlocks(RangeMarker[] markers) throws BadLocationException {
String[] result= new String[markers.length];
for (int i= 0; i < markers.length; i++) {
RangeMarker marker= markers[i];
String content= fDocument.get(marker.getOffset(), marker.getLength());
String lines[]= Strings.convertIntoLines(content);
Strings.trimIndentation(lines, fTypeRoot.getJavaProject(), false);
if (fMarkerMode == STATEMENT_MODE && lines.length == 2 && isSingleControlStatementWithoutBlock()) {
lines[1]= CodeFormatterUtil.createIndentString(1, fTypeRoot.getJavaProject()) + lines[1];
}
result[i]= Strings.concatenate(lines, TextUtilities.getDefaultLineDelimiter(fDocument));
}
return result;
}
private boolean isSingleControlStatementWithoutBlock() {
List<Statement> statements= fDeclaration.getBody().statements();
int size= statements.size();
if (size != 1)
return false;
Statement statement= statements.get(size - 1);
int nodeType= statement.getNodeType();
if (nodeType == ASTNode.IF_STATEMENT) {
IfStatement ifStatement= (IfStatement) statement;
return !(ifStatement.getThenStatement() instanceof Block)
&& !(ifStatement.getElseStatement() instanceof Block);
} else if (nodeType == ASTNode.FOR_STATEMENT) {
return !(((ForStatement)statement).getBody() instanceof Block);
} else if (nodeType == ASTNode.WHILE_STATEMENT) {
return !(((WhileStatement)statement).getBody() instanceof Block);
}
return false;
}
}